自主HttpServer实现（C++实战项目） |
您所在的位置：网站首页 › c++ dup2 › 自主HttpServer实现（C++实战项目） |
自主HttpServer实现（C++实战项目）
|
文章目录
项目介绍CGI技术概念原理
设计框架日志文件TCPServer任务类初始化与启动HttpServerHTTP请求结构HTTP响应结构线程回调EndPoint类EndPoint主体框架读取HTTP请求处理HTTP请求CGI处理非CGI处理
构建HTTP响应发送HTTP响应接入线程池简单测试
项目扩展
项目介绍
该项目是一个基于Http和Tcp协议自主实现的WebServer,用于实现服务器对客户端发送过来的GET和POST请求的接收、解析、处理，并返回处理结果给到客户端。该项目主要背景知识涉及C++、网络分层协议栈、HTTP协议、网络套接字编程、CGI技术、单例模式、多线程编程、线程池等。 项目源码：Click
CGI技术可能大家比较陌生，单拎出来提下。 概念CGI（通用网关接口，Common Gateway Interface）是一种用于在Web服务器上执行程序并生成动态Web内容的技术。CGI程序可以是任何可执行程序，通常是脚本语言，例如Perl或Python。 CGI技术允许Web服务器通过将Web请求传递给CGI程序来执行任意可执行文件。CGI程序接收HTTP请求，并生成HTTP响应以返回给Web服务器，最终返回给Web浏览器。这使得Web服务器能够动态地生成网页内容，与静态HTML文件不同。CGI程序可以处理表单数据、数据库查询和其他任务，从而实现动态Web内容。一些常见的用途包括创建动态网页、在线购物车、用户注册、论坛、网上投票等。 原理通过Web服务器将Web请求传递给CGI程序，CGI程序处理请求并生成响应，然后将响应传递回Web服务器，最终返回给客户端浏览器。这个过程可以概括为： 客户端发送HTTP请求到Web服务器。Web服务器检查请求类型，如果是CGI请求，Web服务器将环境变量和请求参数传递给CGI程序，并等待CGI程序的响应。CGI程序接收请求参数，并执行相应的操作，例如读取数据库或处理表单数据等。CGI程序生成HTTP响应，将响应返回给Web服务器。Web服务器将响应返回给客户端浏览器。
在这个过程中，Web服务器和CGI程序之间通过标准输入和标准输出（建立管道并重定向到标准输入输出）进行通信。Web服务器将请求参数通过环境变量传递给CGI程序，CGI程序将生成的响应通过标准输出返回给Web服务器。此外，CGI程序还可以通过其他方式与Web服务器进行通信，例如通过命令行参数或文件进行交互。 设计框架 日志文件用于记录下服务器运行过程中产生的一些事件。日志格式如下：
日志级别说明： INFO： 表示正常的日志输出，一切按预期运行。WARNING： 表示警告，该事件不影响服务器运行，但存在风险。ERROR： 表示发生了某种错误，但该事件不影响服务器继续运行。FATAL： 表示发生了致命的错误，该事件将导致服务器停止运行。文件名称和行数可以通过C语言中的预定义符号__FILE__和__LINE__，分别可以获取当前文件的名称和当前的行数。 #define INFO 1 #define WARNING 2 #define ERROR 3 #define FATAL 4 // #将宏参数level转为字符串格式 #define LOG(level, message) Log(#level, message, __FILE__, __LINE__) TCPServer思路是：创建一个TCP服务器，并通过初始化、绑定和监听等步骤实现对外服务。 具体实现中，单例模式通过一个名为GetInstance的静态方法实现，该方法首先使用pthread_mutex_t保证线程安全，然后使用静态变量 _svr指向单例对象，如果 _svr为空，则创建一个新的TcpServer对象并初始化，最后返回 _svr指针。由于 _svr是static类型的，因此可以确保整个程序中只有一个TcpServer实例。 Socket方法用于创建一个监听套接字，Bind方法用于将端口号与IP地址绑定，Listen方法用于将监听套接字置于监听状态，等待客户端连接。Sock方法用于返回监听套接字的文件描述符。 #define BACKLOG 5 class TcpServer{ private: int _port; // 端口号 int _listen_sock; // 监听套接字 static TcpServer* _svr; // 指向单例对象的static指针 private: TcpServer(int port) :_port(port) ,_listen_sock(-1) {} TcpServer(const TcpServer&) = delete; TcpServer* operator=(const TcpServer&) = delete; public: static TcpServer* GetInstance(int port)// 单例 { static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER; if (_svr == nullptr) { pthread_mutex_lock(&mtx); if (_svr == nullptr)// 为什么要两个if？ 原因:当首个拿锁者完成了对象创建，之后的线程都不会通过第一个if了，而这期间阻塞的线程开始唤醒，它们则需要靠第二个if语句来避免再次创建对象。 { _svr = new TcpServer(port); _svr -> InitServer(); } pthread_mutex_unlock(&mtx); } return _svr; } void InitServer() { Socket(); // 创建 Bind(); // 绑定 Listen(); // 监听 LOG(INFO, "TcpServer Init Success"); } void Socket() // 创建监听套接字 { _listen_sock = socket(AF_INET, SOCK_STREAM, 0); if (_listen_sock struct sockaddr_in local; memset(&local, 0, sizeof(local)); local.sin_family = AF_INET; local.sin_port = htons(_port); local.sin_addr.s_addr = INADDR_ANY; if (bind(_listen_sock, (struct sockaddr*)&local, sizeof(local)) if (listen(_listen_sock, BACKLOG) return _listen_sock; } ~TcpServer() { if (_listen_sock >= 0) { close(_listen_sock); } } }; // 单例对象指针初始化 TcpServer* TcpServer::_svr = nullptr; 任务类 // 任务类 class Task{ private: int _sock; // 通信套接字 CallBack _handler; // 回调函数 public: Task() {} ~Task() {} Task(int sock) // accept建立连接成功产生的通信套接字sock :_sock(sock) {} // 执行任务 void ProcessOn() { _handler(_sock); //_handler对象的运算符()已经重装，直接调用重载的() } }; 初始化与启动HttpServer这部分包含一个初始化服务器的方法InitServer()和一个启动服务器的方法Loop()。其中InitServer()函数注册了一个信号处理函数，忽略SIGPIPE信号（避免写入崩溃）。而Loop()函数则通过调用TcpServer类的单例对象获取监听套接字，然后通过accept()函数等待客户端连接，每当有客户端连接进来，就创建一个线程来处理该客户端的请求，并把任务放入线程池中。这里的Task是一个简单的封装，它包含一个处理客户端请求的成员函数，该成员函数读取客户端请求，解析请求，然后调用CGI程序来执行请求，最后将响应发送给客户端。 #define PORT 8081 class HttpServer { private: int _port;// 端口号 public: HttpServer(int port) :_port(port) {} ~HttpServer() {} // 初始化服务器 void InitServer() { signal(SIGPIPE, SIG_IGN); // 直接粗暴处理cgi程序写入管道时崩溃的情况，忽略SIGPIPE信号,避免因为一个被关闭的socket连接而使整个进程终止 } // 启动服务器 void Loop() { LOG(INFO, "loop begin"); TcpServer* tsvr = TcpServer::GetInstance(_port); // 获取TCP服务器单例对象 int listen_sock = tsvr->Sock(); // 获取单例对象的监听套接字 while(true) { struct sockaddr_in peer; memset(&peer, 0, sizeof(peer)); socklen_t len = sizeof(peer); int sock = accept(listen_sock, (struct sockaddr*)&peer, &len);// 跟客户端建立连接 if (sock public: // Http请求内容 std::string _request_line; // 请求行 std::vector _request_header; // 请求报头 std::string _blank; // 空行 std::string _request_body; // 请求正文 // 存放解析结果 std::string _method; // 请求方法 std::string _uri; // URI std::string _version; // 版本号 std::unordered_map _header_kv; // 请求报头的内容是以键值对的形式存在的，用hash保存 int _content_length; // 正文长度 std::string _path; // 请求资源的路径 std::string _query_string; // URI携带的参数 // 是否使用CGI bool _cgi; public: HttpRequest() :_content_length(0) // 默认请求正文长度为0 ,_cgi(false) // 默认不适用CGI模式 {} ~HttpRequest() {} }; HTTP响应结构类似的，HTTP响应也封装成一个类，这个类当中包括HTTP响应的内容以及构建HTTP响应所需要的数据。构建响应需要使用的数据就存储在这个类当中，构建后得到的响应内容也存储在这个类当中。 class HttpResponse{ public: // Http响应内容 std::string _status_line; // 状态行 std::vector _response_header; // 响应报头 std::string _blank; // 空行 std::string _response_body; // 响应正文（如果CGI为true（即Get带_query_string或者Post），响应正文才存在） // 所需数据 int _status_code; // 状态码 int _fd; // 响应文件的fd int _size; // 响应文件的大小 std::string _suffix; // 响应文件的后缀 public: HttpResponse() :_blank(LINE_END) ,_status_code(OK) ,_fd(-1) ,_size(0) {} ~HttpResponse() {} }; 线程回调该回调函数实际上是一个函数对象，其重载了圆括号运算符“()”。当该函数对象被调用时，会传入一个int类型的套接字描述符作为参数，代表与客户端建立的连接套接字。该函数对象内部通过创建一个EndPoint对象来处理该客户端发来的HTTP请求，包括读取请求、处理请求、构建响应和发送响应。处理完毕后，该连接套接字将被关闭，EndPoint对象也会被释放。 class CallBack{ public: CallBack() {} ~CallBack() {} // 重载运算符 () void operator()(int sock) { HandlerRequest(sock); } void HandlerRequest(int sock) { LOG(INFO, "HandlerRequest begin"); EndPoint* ep = new EndPoint(sock); ep->RecvHttpRequest(); //读取请求 if (!ep->IsStop()) { LOG(INFO, "RecvHttpRequest Success"); ep->HandlerHttpRequest(); //处理请求 ep->BulidHttpResponse(); //构建响应 ep->SendHttpResponse(); //发送响应 if (ep->IsStop()) { LOG(WARNING, "SendHttpResponse Error, Stop Send HttpResponse"); } } else { LOG(WARNING, "RecvHttpRequest Error, Stop handler Response"); } close(sock); //响应完毕，关闭与该客户端建立的套接字 delete ep; LOG(INFO, "handler request end"); } }; EndPoint类
EndPoint类中包含三个成员变量： sock：表示与客户端进行通信的套接字。http_request：表示客户端发来的HTTP请求。http_response：表示将会发送给客户端的HTTP响应。_stop：是否异常停止本次处理EndPoint类中主要包含四个成员函数： RecvHttpRequest：读取客户端发来的HTTP请求。HandlerHttpRequest：处理客户端发来的HTTP请求。BuildHttpResponse：构建将要发送给客户端的HTTP响应。SendHttpResponse：发送HTTP响应给客户端。 //服务端EndPoint class EndPoint{ private: int _sock; //通信的套接字 HttpRequest _http_request; //HTTP请求 HttpResponse _http_response; //HTTP响应 bool _stop; //是否停止本次处理 public: EndPoint(int sock) :_sock(sock) {} //读取请求 void RecvHttpRequest(); //处理请求 void HandlerHttpRequest(); //构建响应 void BuildHttpResponse(); //发送响应 void SendHttpResponse(); ~EndPoint() {} }; 读取HTTP请求读取HTTP请求的同时可以对HTTP请求进行解析，这里我们分为五个步骤，分别是读取请求行、读取请求报头和空行、解析请求行、解析请求报头、读取请求正文。 // 读取请求：如果请求行和请求报头正常读取，那先解析请求行和请求报头，然后读取请求正文 void RecvHttpRequest() { if (!RecvHttpRequestLine() && !RecvHttpRequestHeader())// 请求行与请求报头读取均正常读取 { ParseHttpRequestLine(); ParseHttpRequestHeader(); RecvHttpRequestBody(); } } 处理HTTP请求首先判断请求方法是否为GET或POST，如果不是则返回错误信息；然后判断请求是GET还是POST，设置对应的cgi、路径和查询字符串；接着拼接web根目录和请求资源路径，并判断路径是否以/结尾，如果是则拼接index.html；获取请求资源文件的属性信息，并根据属性信息判断是否需要使用CGI模式处理；获取请求资源文件的后缀，进行CGI或非CGI处理。
CGI处理时需要创建子进程进行进程程序替换，但是在创建子进程之前需要先创建两个匿名管道。这里站在父进程角度对这两个管道进行命名，父进程用于读取数据的管道叫做input，父进程用于写入数据的管道叫做output。
创建匿名管道并创建子进程后，需要父子进程各自关闭两个管道对应的读写端： 对于父进程来说，input管道是用来读数据的，因此父进程需要保留input[0]关闭input[1]，而output管道是用来写数据的，因此父进程需要保留output[1]关闭output[0]。对于子进程来说，input管道是用来写数据的，因此子进程需要保留input[1]关闭input[0]，而output管道是用来读数据的，因此子进程需要保留output[0]关闭output[1]。此时父子进程之间的通信信道已经建立好了，但为了让替换后的CGI程序从标准输入读取数据等价于从管道读取数据，向标准输出写入数据等价于向管道写入数据，因此在子进程进行进程程序替换之前，还需要对子进程进行重定向。 假设子进程保留的input[1]和output[0]对应的文件描述符分别是3和4，那么子进程对应的文件描述符表的指向大致如下： 现在我们要做的就是将子进程的标准输入重定向到output管道，将子进程的标准输出重定向到input管道，也就是让子进程的0号文件描述符指向output管道，让子进程的1号文件描述符指向input管道。
此外，在子进程进行进程程序替换之前，还需要进行各种参数的传递： 首先需要将请求方法通过putenv函数导入环境变量，以供CGI程序判断应该以哪种方式读取父进程传递过来的参数。如果请求方法为GET方法，则需要将URL中携带的参数通过导入环境变量的方式传递给CGI程序。如果请求方法为POST方法，则需要将请求正文的长度通过导入环境变量的方式传递给CGI程序，以供CGI程序判断应该从管道读取多少个参数。此时子进程就可以进行进程程序替换了，而父进程需要做如下工作： 如果请求方法为POST方法，则父进程需要将请求正文中的参数写入管道中，以供被替换后的CGI程序进行读取。然后父进程要做的就是不断调用read函数，从管道中读取CGI程序写入的处理结果，并将其保存到HTTP响应类的response_body当中。管道中的数据读取完毕后，父进程需要调用waitpid函数等待CGI程序退出，并关闭两个管道对应的文件描述符，防止文件描述符泄露。 // CGI = true，处理cgi int ProcessCgi() { int code = OK; // 要返回的状态码，默认设置为200 auto& bin = _http_request._path; // 需要执行的CGI程序 auto& method = _http_request._method; // 请求方法 //需要传递给CGI程序的参数 auto& query_string = _http_request._query_string; // GET auto& request_body = _http_request._request_body; // POST int content_length = _http_request._content_length; // 请求正文的长度 auto& response_body = _http_response._response_body; // CGI程序的处理结果放到响应正文当中 // 1、创建两个匿名管道（管道命名站在父进程角度） // 在调用 pipe 函数创建管道成功后，pipefd[0] 用于读取数据，pipefd[1] 用于写入数据。 // 1.1 创建从子进程到父进程的通信信道 int input[2]; if(pipe(input) // 管道创建失败，pipe()返回-1 LOG(ERROR, "pipe output error!"); code = INTERNAL_SERVER_ERROR; return code; } //2、创建子进程 pid_t pid = fork(); if(pid == 0){ //child // 子进程关闭两个管道对应的读写端 close(input[0]); close(output[1]); //将请求方法通过环境变量传参 std::string method_env = "METHOD="; method_env += method; putenv((char*)method_env.c_str()); if(method == "GET"){ //将query_string通过环境变量传参 std::string query_env = "QUERY_STRING="; query_env += query_string; putenv((char*)query_env.c_str()); LOG(INFO, "GET Method, Add Query_String env"); } else if(method == "POST"){ //将正文长度通过环境变量传参 std::string content_length_env = "CONTENT_LENGTH="; content_length_env += std::to_string(content_length); putenv((char*)content_length_env.c_str()); LOG(INFO, "POST Method, Add Content_Length env"); } else{ //Do Nothing } //3、将子进程的标准输入输出进行重定向,子进程会继承了父进程的所有文件描述符 dup2(output[0], 0); //标准输入重定向到管道的输入 dup2(input[1], 1); //标准输出重定向到管道的输出 //4、将子进程替换为对应的CGI程序，代码、数据全部替换掉 execl(bin.c_str(), bin.c_str(), nullptr); exit(1); // 替换失败则exit(1) } else if(pid //father //父进程关闭两个管道对应的读写端 close(input[1]); close(output[0]); if(method == "POST") // 将正文中的参数通过管道传递给CGI程序 { const char* start = request_body.c_str(); int total = 0; int size = 0; while(total 0) { total += size; } } // 读取CGI程序的处理结果 char ch = 0; while(read(input[0], &ch, 1) > 0)// 不会一直读，当另一端关闭后会继续往下执行 { response_body.push_back(ch); } // 等待子进程（CGI程序）退出 // status 保存退出状态 int status = 0; pid_t ret = waitpid(pid, &status, 0); if(ret == pid){ if(WIFEXITED(status)){ // 子进程正常退出 if(WEXITSTATUS(status) == 0){ // 子进程退出码结果正确 LOG(INFO, "CGI program exits normally with correct results"); code = OK; } else{ LOG(INFO, "CGI program exits normally with incorrect results"); code = BAD_REQUEST; } } else{ LOG(INFO, "CGI program exits abnormally"); code = INTERNAL_SERVER_ERROR; } } //关闭两个管道对应的文件描述符 close(input[0]); close(output[1]); } return code; //返回状态码 } 非CGI处理 非CGI处理时只需要将客户端请求的资源构建成HTTP响应发送给客户端即可，理论上这里要做的就是打开目标文件，将文件中的内容读取到HTTP响应类的response_body中，以供后续发送HTTP响应时进行发送即可，但这种做法还可以优化。 因为HTTP响应类的response_body属于用户层的缓冲区，而目标文件是存储在服务器的磁盘上的，按照这种方式需要先将文件内容读取到内核层缓冲区，再由操作系统将其拷贝到用户层缓冲区，发送响应正文的时候又需要先将其拷贝到内核层缓冲区，再由操作系统将其发送给对应的网卡进行发送。我们完全可以调用sendfile函数直接将磁盘当中的目标文件内容读取到内核，再由内核将其发送给对应的网卡进行发送。 sendfile函数是一个系统调用函数，用于将一个文件描述符指向的文件内容直接发送给另一个文件描述符指向的套接字，从而实现了零拷贝（Zero Copy）技术。这种技术避免了数据在用户态和内核态之间的多次拷贝，从而提高了数据传输效率。 sendfile函数的使用场景通常是在Web服务器中，用于将静态文件直接发送给客户端浏览器，从而避免了将文件内容复制到用户空间的过程。在Linux系统中，sendfile函数的原型为： #include ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t count); 其中，out_fd表示目标文件描述符，in_fd表示源文件描述符，offset表示源文件偏移量，count表示要发送的字节数。函数返回值表示成功发送的字节数，如果返回-1则表示出现了错误。 // CGI = false int ProcessNonCgi() { // 打开客户端请求的资源文件，以供后续发送 _http_response._fd = open(_http_request._path.c_str(), O_RDONLY); if(_http_response._fd >= 0){ // 打开文件成功 return OK; } return INTERNAL_SERVER_ERROR; // 打开文件失败 } 构建HTTP响应构建 HTTP 响应报文，首先根据响应的状态码构建状态行（包含 HTTP 版本、状态码和状态码描述），然后根据状态码分别构建不同的响应报头和响应正文。如果状态码为 200 OK，则调用 BuildOkResponse() 函数构建成功的响应报头和响应正文；如果状态码为 404 NOT FOUND、400 BAD REQUEST 或 500 INTERNAL SERVER ERROR，则根据不同的状态码构建相应的错误响应报头和响应正文，并调用 HandlerError() 函数处理错误。 // 构建响应 void BulidHttpResponse() { int code = _http_response._status_code; //构建状态行 auto& status_line = _http_response._status_line; status_line += HTTP_VERSION; status_line += " "; status_line += std::to_string(code); status_line += " "; status_line += CodeToDesc(code); //根据状态码获取状态码描述 status_line += LINE_END; //构建响应报头 std::string path = WEB_ROOT; path += "/"; switch(code){ case OK: BuildOkResponse(); break; case NOT_FOUND: path += PAGE_404; HandlerError(path); break; case BAD_REQUEST: path += PAGE_400; HandlerError(path); break; case INTERNAL_SERVER_ERROR: path += PAGE_500; HandlerError(path); break; default: break; } } 发送HTTP响应发送HTTP响应的步骤如下： 调用send函数，依次发送状态行、响应报头和空行。发送响应正文时需要判断本次请求的处理方式，如果本次请求是以CGI方式成功处理的，那么待发送的响应正文是保存在HTTP响应类的response_body中的，此时调用send函数进行发送即可。如果本次请求是以非CGI方式处理或在处理过程中出错的，那么待发送的资源文件或错误页面文件对应的文件描述符是保存在HTTP响应类的fd中的，此时调用sendfile进行发送即可，发送后关闭对应的文件描述符。 // 发送响应 bool SendHttpResponse() { //发送状态行 if(send(_sock, _http_response._status_line.c_str(), _http_response._status_line.size(), 0) for(auto& iter : _http_response._response_header) { if(send(_sock, iter.c_str(), iter.size(), 0) if(send(_sock, _http_response._blank.c_str(), _http_response._blank.size(), 0) if(!_stop) { auto& response_body = _http_response._response_body; const char* start = response_body.c_str(); size_t size = 0; size_t total = 0; while(total 0){ total += size; } } } else { if(!_stop) { // sendfile：这是一个系统调用，用于高效地从文件传输数据到套接字中。它避免了在内核空间和用户空间之间复制数据的需求，从而实现更快的数据传输。 if(sendfile(_sock, _http_response._fd, nullptr, _http_response._size) private: std::queue _task_queue; //任务队列 int _num; //线程池中线程的个数 pthread_mutex_t _mutex; //互斥锁 pthread_cond_t _cond; //条件变量 static ThreadPool* _inst; //指向单例对象的static指针 private: //构造函数私有 ThreadPool(int num = NUM) :_num(num) { //初始化互斥锁和条件变量 pthread_mutex_init(&_mutex, nullptr); pthread_cond_init(&_cond, nullptr); } // 删除拷贝构造函数（防拷贝） ThreadPool(const ThreadPool&)=delete; //判断任务队列是否为空 bool IsEmpty() { return _task_queue.empty(); } //任务队列加锁 void LockQueue() { pthread_mutex_lock(&_mutex); } //任务队列解锁 void UnLockQueue() { pthread_mutex_unlock(&_mutex); } //让线程在条件变量下进行等待 void ThreadWait() { pthread_cond_wait(&_cond, &_mutex); } //唤醒在条件变量下等待的一个线程 void ThreadWakeUp() { pthread_cond_signal(&_cond); } public: //获取单例对象 static ThreadPool* GetInstance() { static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER; //定义静态的互斥锁 //双检查加锁 if(_inst == nullptr){ pthread_mutex_lock(&mtx); //加锁 if(_inst == nullptr){ //创建单例线程池对象并初始化 _inst = new ThreadPool(); _inst->InitThreadPool(); } pthread_mutex_unlock(&mtx); //解锁 } return _inst; //返回单例对象 } //线程的执行例程 static void* ThreadRoutine(void* arg) { pthread_detach(pthread_self()); //线程分离 ThreadPool* tp = (ThreadPool*)arg; while(true){ tp->LockQueue(); //加锁 while(tp->IsEmpty()){ //任务队列为空，线程进行wait tp->ThreadWait(); } Task task; tp->PopTask(task); //获取任务 tp->UnLockQueue(); //解锁 task.ProcessOn(); //处理任务 } } //初始化线程池 bool InitThreadPool() { //创建线程池中的若干线程 pthread_t tid; for(int i = 0;i LOG(FATAL, "create thread pool error!"); return false; } } LOG(INFO, "create thread pool success"); return true; } //将任务放入任务队列 void PushTask(const Task& task) { LockQueue(); //加锁 _task_queue.push(task); //将任务推入任务队列 UnLockQueue(); //解锁 ThreadWakeUp(); //唤醒一个线程进行任务处理 } //从任务队列中拿任务 void PopTask(Task& task) { //获取任务 task = _task_queue.front(); _task_queue.pop(); } ~ThreadPool() { //释放互斥锁和条件变量 pthread_mutex_destroy(&_mutex); pthread_cond_destroy(&_cond); } }; //单例对象指针初始化为nullptr ThreadPool* ThreadPool::_inst = nullptr; 简单测试默认页面测试：
带query_string，CGI传参测试：
当前项目的重点在于HTTP服务器后端的处理逻辑，主要完成的是GET和POST请求方法，以及CGI机制的搭建。还可以进行不少扩展，比如： 当前项目编写的是HTTP1.0版本的服务器，每次连接都只会对一个请求进行处理，当服务器对客户端的请求处理完毕并收到客户端的应答后，就会直接断开连接。可以将其扩展为HTTP1.1版本，让服务器支持长连接，即通过一条连接可以对多个请求进行处理，避免重复建立连接（涉及连接管理）。当前项目虽然在后端接入了线程池，但是效果有限，可以将线程池换成epoll版本，让服务器的IO变得更高效。可以给当前的HTTP服务器新增代理功能，也就是可以替代客户端去访问某种服务，然后将访问结果再返回给客户端（比如课题中的数据备份、数据计算等等）。 |
【本文地址】